package it.okkam.utility;

import it.okkam.costants.Costanti;
import it.okkam.giovo.DatiCatastoGiovoEdificiali;
import it.okkam.strutturedati.AttributiParticella;
import it.okkam.strutturedati.ParticellaCatastale;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

public class UtilityPertinenze {
	
	/**
	 * creaListaAttributi crea la lista degli attributi partendo dall'indirizzo del file contenente gli attributi
	 *
	 * @param  fileAttributiPath  	percorso del file degli attributi
	 * @return      				lista degli attributi
	
	 */
	
	public ArrayList<AttributiParticella> creaListaAttributi(String fileAttributiPath){
		
		ArrayList<String> contenutoFileAttributi = null;
		Utility ut = new Utility();
		ApriStream apriStream = new ApriStream();
		ArrayList<AttributiParticella> listaAttributiLetti = new ArrayList<AttributiParticella>();
		
		contenutoFileAttributi = apriStream.apriStream(fileAttributiPath);
		listaAttributiLetti = ut.leggiAttributi(contenutoFileAttributi);
		
		return listaAttributiLetti;
	
	}
	
	
	/**
	 * CreateHahMap crea una HashMap  con key il valore progressivo della pertinenza 
	 * e in value viene caricato invece la stringa contenente, se presente, il punto  
	 * il numero, e se presente il denominatore 
	 *
	 * @param  listaAttr  	lista degli attributi
	 * @return      		Hashmap con progressivo e dato particella
	
	 */

	public HashMap<String, String> createHashMap (ArrayList<AttributiParticella> listaAttr){
	
		HashMap<String,String> map = new HashMap();
		for (int i = 0; i < listaAttr.size(); i++) {	
			AttributiParticella attrPar = listaAttr.get(i);
			String particellaString = "" ;
			String key = null;
			
			
			if (attrPar.getPrincipalePertinenza().equalsIgnoreCase("pertinenza")){
				if (attrPar.isPresenzaPunto()){ 
					particellaString = stringAdd(particellaString,  ".");
				}
				particellaString = stringAdd(particellaString, attrPar.getNumero());
				if (attrPar.getDenominatore()!= null){
					particellaString = stringAdd(particellaString, "/" +  attrPar.getDenominatore());
				}
				key = attrPar.getProgressivo();
				map.put(key, particellaString);
			}
			
			
		}return map;
		}
	
	
	/**
	 * Metodo che controlla nella HashMap, passata come parametro, quante occorrenze ci sono per lo stesso valore.
	 * Ogni volta che trova un'occorrenza viene aggiunto un *numero con numero progressivo che parte da 1. 
	 * 
	 * @param elencoPertinenze
	 * @return hash map con progressivi
	 */
	public HashMap<String, String> appendProgressivo (HashMap<String, String> elencoPertinenze){
		HashMap<String, String> map = elencoPertinenze;
				
		for ( String key1 : map.keySet() ) {
			String contenuto1 = map.get(key1);
			int count=1; 
			boolean check=false;
			for ( String key2 : map.keySet() ) {
				String contenuto2 = map.get(key2);	
				
				if(!key1.equals(key2)){
					if(contenuto1.equals(contenuto2)){
						check=true;
						//INCREMENTARE CONTANTORE
						count=count+1;
						map.put(key2, contenuto2+"*"+count);
					}
				}
			}
			if(check)
				map.put(key1, contenuto1+"*1");
		
		}
		
		//codice di test per controllare i valori con i progressivi
		/*
	    Iterator<String> iterator = map.keySet().iterator();
	    while (iterator.hasNext()) {
	    	String key = (String) iterator.next();
	    	String cont = map.get(key);
			if(cont.contains(".726")){
				System.out.println(key+" --> "+cont);
			}
		}
		*/
		return map;
	}
	
	private String getIndexMax(String particellaString, HashMap<String, String> mappa) {
		String indexMax = null;
		
		
		return indexMax;
		
	}
	
	public static String convertSimple(int i) {
	    return "" + i;
	}
	
	public static String stringAdd (String first, String second) {
	    String result = first + second;
		return result;
	}

	public static boolean isStar (String stringaIndagata){
		boolean yesOrNo= false;
		if (stringaIndagata.contains("*")){yesOrNo= true;}
		return yesOrNo;
	}
	
	public static boolean isSlash (String stringaIndagata){
		boolean yesOrNo= false;
		if (stringaIndagata.contains("/")){yesOrNo= true;}
		return yesOrNo;
		
	}
	
	public int trovaPosizioneStar(String stringaIndagata) {

		int i = 0;

		for (int j = 0; j < stringaIndagata.length(); j++) {

			if (stringaIndagata.charAt(j) == '*') {

				i = j;}
		}
		return i;
	}
	
	public ArrayList<AttributiParticella> conversionHMToList (HashMap<String, String> map){
		ArrayList<AttributiParticella> listaAttributiLetti = new ArrayList<AttributiParticella>();
		
		
		boolean presenzaPunto = false;
		String denominatore;
		String numero;
		int posizioneSlash;
		String numeroPertinenza = "1";
		
		// .726/1*8
		
		for ( String key : map.keySet() ) {
			Utility ut = new Utility();
			
			String contenuto = map.get(key);
			AttributiParticella attr = new AttributiParticella();
			attr.setProgressivo(key);
			presenzaPunto = false;
			if (ut.trovaPunto(contenuto)){
				presenzaPunto = true;
				contenuto = contenuto.substring(1);
				}
		
			if (isStar(contenuto)){
				int posizioneStar = trovaPosizioneStar(contenuto);
				int lenghtContenuto = contenuto.length();
				numeroPertinenza = contenuto.substring(posizioneStar+1, lenghtContenuto );
				contenuto = contenuto.substring(0, posizioneStar);
				attr.setNumeroPertinenza(numeroPertinenza);
			}
			
			if (isSlash(contenuto)){
				posizioneSlash =  ut.trovaPosizioneSlash(contenuto);
				numero = contenuto.substring(0, posizioneSlash);
				denominatore = contenuto.substring(posizioneSlash+1, contenuto.length());
				attr.setDenominatore(denominatore);
			}
			else {
				numero = contenuto;
			}
			attr.setPresenzaPunto(presenzaPunto);
			attr.setNumero(numero);
			attr.setPrincipalePertinenza("pertinenza");
			listaAttributiLetti.add(attr);
			
			}
		
		return listaAttributiLetti;
	}
}
